package cn.jetpiece.cloud.core.filters;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.jetpiece.cloud.config.properties.JetpieceGatewayProperties;
import cn.jetpiece.cloud.core.consts.GatewayConstants;
import cn.jetpiece.cloud.core.util.IpInfoUtils;
import cn.jetpiece.cloud.jwt.utils.JwtTokenUtil;
import cn.jetpiece.cloud.log.api.GatewayLogApi;
import cn.jetpiece.cloud.log.api.model.params.GatewayLogParam;
import cn.jetpiece.cloud.redis.utils.RedisUtil;
import cn.jetpiece.cloud.resource.annotation.keys.ResourceKey;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.factory.rewrite.CachedBodyOutputMessage;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.support.BodyInserterContext;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.HandlerStrategies;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Slf4j
@Component
public class GatewayLogFilter implements GlobalFilter, Ordered {

    private final List<HttpMessageReader<?>> messageReaders = HandlerStrategies.withDefaults().messageReaders();

    @Override
    public int getOrder() {
        return -99;
    }

    @Override
    @SuppressWarnings("unchecked")
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        if (!JetpieceGatewayProperties.getInstance().getEnableLog()) {
            return chain.filter(exchange);
        }
        ServerHttpRequest request = exchange.getRequest();

        String ignoreUrl = request.getHeaders().getFirst(GatewayConstants.IGNORE_URL);
        if (StrUtil.isNotBlank(ignoreUrl)) {
            return chain.filter(exchange.mutate().request(request).build());
        }

        String resourceKey = request.getHeaders().getFirst(ResourceKey.REQUEST_RESOURCE_KEY);

        Route route = getGatewayRoute(exchange);
        String ipAddress = IpInfoUtils.getIpAddr(request);
        GatewayLogParam gatewayLog = new GatewayLogParam();
        gatewayLog.setRequestSchema(request.getURI().getScheme());
        gatewayLog.setRequestMethod(request.getMethodValue());
        gatewayLog.setRequestHeader(JSONObject.toJSONString(request.getHeaders()));
        if (resourceKey != null) {
            gatewayLog.setRequestPath(resourceKey.substring(resourceKey.indexOf(ResourceKey.RES_METHOD_URL_SEPARATOR) + 1));
        }
        if(StrUtil.isBlank(gatewayLog.getRequestPath())){
            gatewayLog.setRequestPath(extractPathWithQueryString(request));
        }
        gatewayLog.setTargetServer(route.getId());
        gatewayLog.setRequestTime(new Date());
        gatewayLog.setIpAddress(ipAddress);

        String token = request.getHeaders().getFirst(GatewayConstants.AUTH_HEADER);
        setUserInfo(gatewayLog, token);

        String strApplicationId = request.getHeaders().getFirst(GatewayConstants.APPLICATION_ID_HEADER);
        if (StrUtil.isNotBlank(strApplicationId)) {
            try {
                gatewayLog.setUserId(Long.parseLong(strApplicationId));
            } catch (Exception e) {
                log.warn("parse " + GatewayConstants.APPLICATION_ID_HEADER + " [" + strApplicationId + "] error.caused by:" + e.getMessage(), e);
            }
        }

        MediaType mediaType = request.getHeaders().getContentType();
        if (MediaType.APPLICATION_FORM_URLENCODED.isCompatibleWith(mediaType) || MediaType.APPLICATION_JSON.isCompatibleWith(mediaType)) {
            return writeBodyLog(exchange, chain, gatewayLog);
        } else {
            return writeBasicLog(exchange, chain, gatewayLog);
        }
    }

    private String extractPathWithQueryString(ServerHttpRequest request) {
        String path = request.getPath().toString();
        if (!request.getQueryParams().isEmpty()) {
            MultiValueMap<String, String> queryParams = request.getQueryParams();
            List<String> list = new ArrayList<>();
            for (String key : queryParams.keySet()) {
                list.add(key + "=" + queryParams.getFirst(key));
            }
            String strQueryString = String.join("&", list);
            path = path + "?" + strQueryString;
        }
        return path;
    }

    private Mono<Void> writeBasicLog(ServerWebExchange exchange, GatewayFilterChain chain, GatewayLogParam accessLog) {
        StringBuilder builder = new StringBuilder();
        MultiValueMap<String, String> queryParams = exchange.getRequest().getQueryParams();
        for (Map.Entry<String, List<String>> entry : queryParams.entrySet()) {
            builder.append(entry.getKey()).append("=").append(StrUtil.join(",", entry.getValue())).append("&");
        }
        accessLog.setRequestBody(builder.toString());
        //获取响应体
        ServerHttpResponseDecorator decoratedResponse = recordResponseLog(exchange, accessLog);
        return chain.filter(exchange.mutate().response(decoratedResponse).build())
                .then(Mono.fromRunnable(() -> {
                    // 打印日志
                    writeAccessLog(accessLog);
                }));
    }


    /**
     * 解决 request body 只能读取一次问题，
     * 参考: org.springframework.cloud.gateway.filter.factory.rewrite.ModifyRequestBodyGatewayFilterFactory
     */
    @SuppressWarnings("unchecked")
    private Mono writeBodyLog(ServerWebExchange exchange, GatewayFilterChain chain, GatewayLogParam gatewayLog) {
        ServerRequest serverRequest = ServerRequest.create(exchange, messageReaders);
        Mono<String> modifiedBody = serverRequest.bodyToMono(String.class)
                .flatMap(body -> {
                    gatewayLog.setRequestBody(body);
                    return Mono.just(body);
                });
        // 通过 BodyInserter 插入 body(支持修改body), 避免 request body 只能获取一次
        BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
        HttpHeaders headers = new HttpHeaders();
        headers.putAll(exchange.getRequest().getHeaders());
        // the new content type will be computed by bodyInserter
        // and then set in the request decorator
        headers.remove(HttpHeaders.CONTENT_LENGTH);
        CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);
        return bodyInserter.insert(outputMessage, new BodyInserterContext())
                .then(Mono.defer(() -> {
                    // 重新封装请求
                    ServerHttpRequest decoratedRequest = requestDecorate(exchange, headers, outputMessage);
                    // 记录响应日志
                    ServerHttpResponseDecorator decoratedResponse = recordResponseLog(exchange, gatewayLog);
                    // 记录普通的
                    return chain.filter(exchange.mutate().request(decoratedRequest).response(decoratedResponse).build())
                            .then(Mono.fromRunnable(() -> {
                                // 打印日志
                                writeAccessLog(gatewayLog);
                            }));
                }));
    }

    /**
     * 打印日志
     *
     * @param gatewayLog 网关日志
     */
    private void writeAccessLog(GatewayLogParam gatewayLog) {
        Long size = RedisUtil.getInstance().getRedisTemplate().opsForList().size(GatewayLogApi.GATEWAY_LOG_CACHE);
        /* 最大一万的队列 */
        if (size != null && size > 10000) {
            log.warn(gatewayLog.toString());
        } else {
            RedisUtil.getInstance().getRedisTemplate().opsForList().leftPush(GatewayLogApi.GATEWAY_LOG_CACHE, gatewayLog);
        }
    }

    private Route getGatewayRoute(ServerWebExchange exchange) {
        return exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
    }

    /**
     * 请求装饰器，重新计算 headers
     */
    private ServerHttpRequestDecorator requestDecorate(ServerWebExchange exchange, HttpHeaders headers, CachedBodyOutputMessage outputMessage) {
        return new ServerHttpRequestDecorator(exchange.getRequest()) {
            @Override
            public HttpHeaders getHeaders() {
                long contentLength = headers.getContentLength();
                HttpHeaders httpHeaders = new HttpHeaders();
                httpHeaders.putAll(super.getHeaders());
                if (contentLength > 0) {
                    httpHeaders.setContentLength(contentLength);
                } else {
                    // TODO: this causes a 'HTTP/1.1 411 Length Required' // on
                    // http bin.org
                    httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
                }
                return httpHeaders;
            }

            @Override
            public Flux<DataBuffer> getBody() {
                return outputMessage.getBody();
            }
        };
    }

    /**
     * 记录响应日志
     * 通过 DataBufferFactory 解决响应体分片传输问题。
     */
    private ServerHttpResponseDecorator recordResponseLog(ServerWebExchange exchange, GatewayLogParam gatewayLog) {
        ServerHttpResponse response = exchange.getResponse();
        DataBufferFactory bufferFactory = response.bufferFactory();
        return new ServerHttpResponseDecorator(response) {
            @Override
            public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                if (body instanceof Flux) {
                    Date responseTime = new Date();
                    gatewayLog.setResponseTime(responseTime);
                    // 计算执行时间
                    long executeTime = (responseTime.getTime() - gatewayLog.getRequestTime().getTime());
                    gatewayLog.setExecuteTime(executeTime);
                    // 获取响应类型，如果是 json 就打印
                    String originalResponseContentType = exchange.getAttribute(ServerWebExchangeUtils.ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR);
                    if (ObjectUtil.equal(this.getStatusCode(), HttpStatus.OK) && StrUtil.isNotBlank(originalResponseContentType) && originalResponseContentType.contains("application/json")) {
                        Flux<? extends DataBuffer> fluxBody = Flux.from(body);
                        return super.writeWith(fluxBody.buffer().map(dataBuffers -> {
                            // 合并多个流集合，解决返回体分片传输
                            DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
                            DataBuffer join = dataBufferFactory.join(dataBuffers);
                            byte[] content = new byte[join.readableByteCount()];
                            join.read(content);
                            // 释放掉内存
                            DataBufferUtils.release(join);
                            String responseResult = new String(content, StandardCharsets.UTF_8);
                            if (gatewayLog.getRequestPath() != null &&(gatewayLog.getRequestPath().contains("/api/auth/ecsLogin") || gatewayLog.getRequestPath().contains("/auth/token"))) {
                                JSONObject jsonObject = JSONObject.parseObject(responseResult);
                                JSONObject data = jsonObject.getJSONObject("data");
                                if (data != null) {
                                    String token = data.getString("token");
                                    setUserInfo(gatewayLog, token);
                                }
                            }
                            gatewayLog.setResponseData(responseResult);
                            return bufferFactory.wrap(content);
                        }));
                    }
                }
                // if body is not a flux. never got there.
                return super.writeWith(body);
            }
        };
    }

    /**
     * 设置用户信息
     */
    private void setUserInfo(GatewayLogParam gatewayLogParam, String token) {
        if (StrUtil.isNotBlank(token) && JwtTokenUtil.getINSTANCE().checkToken(token)) {
            gatewayLogParam.setUserId(JwtTokenUtil.getINSTANCE().getUserId(token));
            gatewayLogParam.setUsername(JwtTokenUtil.getINSTANCE().getUsername(token));

        }
    }
}
